/*
 * Entidades.cpp
 *
 *  Created on: 05/10/2014
 *      Author:
 */

#include <iostream>
#include <fstream>
#include "ArchivoDeBloques/ArchivoDeBloques.h"
#include <cstring>
using namespace std;


/*IDEA:
 * Cada entidad va a estar almacenada en un bloque distinto.
 * Cada metadata o atributo de la entidad va a ser un registro dentro del bloque.
 * Opciones de atributos:
 * Entero: E
 * Cadena de caracteres: C
 * Otra entidad: X
 *
 * En el caso de ser cadena en el registro siguiente se especifica la longitud maxima de la misma.
 *
 * Ademas despues del nombre se guarda S o N dependiendo de si el atributo es obligatorio.
 *
 *
 * De esta manera asi queda representada una entidad.
 * NOMBRE$ID_ENTIDAD$(NOMBRE_DE_ATRIBUTO$S_N$TIPO_ATRIBUTO)+
 *
 * Por ejemplo, segun el ejemplo de entidad (pag. 12):
 * CORPINO$1$DESCRIPCION$50$S$C$COLOR$S$X$CONTORNO$N$X$COPA$N$X$BRETEL$N$X
 * CONTORNO$2$DESCRIPCION$50$S$C
 * COPA$3$DESCRIPCION$50$S$C
 * BRETEL$4$DESCRIPCION$50$S$C
 *
 */
/*void cargarEntidades ()
{

    unsigned int tamBloque =90;
    unsigned int nroBloqueActual=0;
    int res ;
	ArchivoDeBloques archivoEntidades("entidades", tamBloque);

	//Como las entidades son fijas las creamos como un unico registro

	Bloque bloque1 (tamBloque);
	Registro corpino("CORPINO$1$DESCRIPCION$50$S$C$COLOR$S$X$CONTORNO$N$X$COPA$N$X$BRETEL$N$X");
	bloque1.agregarRegistro(corpino);
	archivoEntidades.escribirBloque(bloque1, nroBloqueActual);

	nroBloqueActual++;

	Bloque bloque2 (tamBloque);
	Registro contorno("CONTORNO$2$DESCRIPCION$50$S$C");
	bloque2.agregarRegistro(contorno);
	archivoEntidades.escribirBloque(bloque2, nroBloqueActual);

	nroBloqueActual++;

	Bloque bloque3 (tamBloque);
	Registro copa("COPA$3$DESCRIPCION$50$S$C");
	bloque3.agregarRegistro(copa);
	archivoEntidades.escribirBloque(bloque3, nroBloqueActual);

	nroBloqueActual++;

	Bloque bloque4 (tamBloque);
	Registro bretel("BRETEL$4$DESCRIPCION$50$S$C");
	bloque4.agregarRegistro(bretel);
	archivoEntidades.escribirBloque(bloque4, nroBloqueActual);

	Bloque* bloqueLeido;
	for (int i=0; i<4;i++){
		bloqueLeido = archivoEntidades.leerBloque(i);
		cout << "Bloque "<< i << ": " <<(*bloqueLeido).bufferBloque << endl;
	}

}

void leerEntidades (){
	ArchivoDeBloques archivoEntidades("entidades");

	Bloque* bloqueLeido;
	for (int i=0; i<4;i++){
		bloqueLeido = archivoEntidades.leerBloque(i);
		cout << "Bloque "<< i << ": " <<(*bloqueLeido).bufferBloque << endl;
	}

}*/

void cargarEntidades_old ()
{
    unsigned int tamArchBloque = 500;
    unsigned int tamBloque =50;//bytes
    int res ;
	ArchivoDeBloques archivoEntidades("entidades.dat", tamArchBloque);

    //Genera la estructura de las ENTIDADES
	//entidad CORPINO
	Registro reg1_cabecera("CORPINO");
	Registro reg1_idReg("ID_CORPINO");
	Registro reg1_atributo1("CONTORNO");
	Registro reg1_atributo2("COPA");
	//Registro reg1_atributo3("BRETEL");//no lo agrega
    //entidad BRETEL
	Registro reg2_cabecera("BRETEL");
	Registro reg2_idReg("ID_BRETEL");	
	Registro reg2_atributo1("MONTABLE");
	Registro reg2_atributo2("FIJO");
	Registro reg2_atributo3("SIN_BRETEL");
      //entidad COPA
	Registro reg3_cabecera("COPA");
	Registro reg3_idReg("ID_COPA");		
	Registro reg3_atributo1("ARMADO");
	Registro reg3_atributo2("SIN_ARMAR");
	Registro reg3_atributo3("ARO");
    Registro reg3_atributo4("FORMADORES");

    //Genera el BLOQUE de ENTIDAD CORPINO
	//Bloque 1
	Bloque blqEnt1(tamBloque);
    //Agrego los registros
	res= blqEnt1.agregarRegistro(reg1_cabecera);
	if (res != -1) {
		cout << "no hay espacio para reg1_cabecera" << endl;
	}
	res= blqEnt1.agregarRegistro(reg1_idReg);
	if (res != -1) {
		cout << "no hay espacio para reg1_idReg" << endl;
	}
	res= blqEnt1.agregarRegistro(reg1_atributo1);
	if (res != -1) {
		cout << "no hay espacio para reg1_atributo1" << endl;
	}
	res= blqEnt1.agregarRegistro(reg1_atributo2);
	if (res != -1) {
		cout << "no hay espacio para reg1_atributo2" << endl;
	}
	//res= blqEnt1.agregarRegistro(reg1_atributo3);
	//if (res != -1) {
	//	cout << "no hay espacio para reg1_atributo3" << endl;
	//}
	//escribe el bloque en el archivo de entidades
	archivoEntidades.escribirBloque(blqEnt1,1);
	//libera el espacio de Bloque
	blqEnt1.~Bloque();

    //Genera el BLOQUE de ENTIDAD BRETEL
	//Bloque 2    
    Bloque blqEnt2(tamBloque);
    //Agrego los registros
	cout <<"tam bloque libres"<< blqEnt2.obtenerBytesLibres() << endl;

    res=blqEnt2.agregarRegistro(reg2_cabecera);
	if (res != -1) {
		cout << "no hay espacio para reg2_cabecera" << endl;
	}
	res=blqEnt2.agregarRegistro(reg2_idReg);
	if (res != -1) {
		cout << "no hay espacio para reg2_idReg" << endl;
	}
	res=0;
	res=blqEnt2.agregarRegistro(reg2_atributo1);
	if (res != -1) {
		cout << "no hay espacio para reg2_atributo1" << endl;
	}
	cout <<"bloque libres"<< blqEnt2.obtenerBytesLibres() << endl;

	res=blqEnt2.agregarRegistro(reg2_atributo2);
	if (res != -1) {
		cout << "no hay espacio para reg2_atributo2" << endl;
	}
	//res=blqEnt2.agregarRegistro(reg2_atributo3);
	//if (res != -1) {
	//	cout << "no hay espacio para reg2_atributo3" << endl;
	//}
	//escribe el bloque en el archivo de entidades 2
	archivoEntidades.escribirBloque(blqEnt2,2);
	//libera el espacio de Bloque
	blqEnt2.~Bloque();

    //Genera el BLOQUE de ENTIDAD COPA
	//Bloque 3 
    Bloque blqEnt3(tamBloque);
     //Agrego los registros	  
	res=blqEnt3.agregarRegistro(reg3_cabecera);
	if (res != -1) {
		cout << "no hay espacio para reg3_cabecera" << endl;
	}
	res=blqEnt3.agregarRegistro(reg3_idReg);
	if (res != -1) {
		cout << "no hay espacio para reg3_idReg" << endl;
	}
	res=blqEnt3.agregarRegistro(reg3_atributo1);
	if (res != -1) {
		cout << "no hay espacio para reg3_atributo1" << endl;
	}
	res=blqEnt3.agregarRegistro(reg3_atributo2);
	if (res != -1) {
		cout << "no hay espacio para reg3_atributo2" << endl;
	}
	//res=blqEnt3.agregarRegistro(reg3_atributo3);
	//if (res != -1) {
	//	cout << "no hay espacio para reg3_atributo3" << endl;
	//}
	//res=blqEnt3.agregarRegistro(reg3_atributo4);
	//if (res != -1) {
	//	cout << "no hay espacio para reg3_atributo4" << endl;
	//}
	//escribe el bloque en el archivo de entidades 3
	archivoEntidades.escribirBloque(blqEnt3,3);
	//libera el espacio de Bloque
	blqEnt3.~Bloque();

}

void cargarInstancias ()
{
    unsigned int tamArchBloque = 500;
    unsigned int tamBloque =25;//bytes
    int res = 0;

    ArchivoDeBloques archivoInstancias("instancias.dat", tamArchBloque);

	//instancia de CORPINO, con contorno, copa armada y sin bretel
	Registro reg1_i1_cabecera("CORPINO");
	Registro reg1_i1_idReg("1"); //no se como guardara 001. OJO
	Registro reg1_i1_atributo1("S");
	Registro reg1_i1_atributo2("S");
	Registro reg1_i1_atributo3("N");

	//instancia de CORPINO, con contorno, copa armada y sin bretel
	Registro reg1_i2_cabecera("CORPINO");
	Registro reg1_i2_idReg("2"); //no se como guardara 001. OJO
	Registro reg1_i2_atributo1("S");
	Registro reg1_i2_atributo2("S");
	Registro reg1_i2_atributo3("N");

    //copia la primera instancia
	Bloque blqInstancia1(tamBloque);
    //Agrego los registros
	res=blqInstancia1.agregarRegistro(reg1_i1_cabecera);
	if (res != -1) {
		cout << "no hay espacio para reg1_i1_cabecera" << endl;
	}
	res=blqInstancia1.agregarRegistro(reg1_i1_idReg);
	if (res != -1) {
		cout << "no hay espacio para reg1_i1_idReg" << endl;
	}
	res=blqInstancia1.agregarRegistro(reg1_i1_atributo1);
	if (res != -1) {
		cout << "no hay espacio para reg1_i1_atributo1" << endl;
	}
	res=blqInstancia1.agregarRegistro(reg1_i1_atributo2);
	if (res != -1) {
		cout << "no hay espacio para reg1_i1_atributo2" << endl;
	}
	res=blqInstancia1.agregarRegistro(reg1_i1_atributo3);
	if (res != -1) {
		cout << "no hay espacio para reg1_i1_atributo3" << endl;
	}
	//escribe el bloque en el archivo de entidades
	archivoInstancias.escribirBloque(blqInstancia1,1);
	//libera el espacio de Bloque
	blqInstancia1.~Bloque();
    //copia la segunda instancia
	Bloque blqInstancia2(tamBloque);
    //Agrego los registros
	res=blqInstancia2.agregarRegistro(reg1_i2_cabecera);
	if (res != -1) {
		cout << "no hay espacio para reg1_i2_cabecera" << endl;
	}
	res=blqInstancia2.agregarRegistro(reg1_i2_idReg);
	if (res != -1) {
		cout << "no hay espacio para reg1_i2_idReg" << endl;
	}
	res=blqInstancia2.agregarRegistro(reg1_i2_atributo1);
	if (res != -1) {
		cout << "no hay espacio para reg1_i2_atributo1" << endl;
	}
	res=blqInstancia2.agregarRegistro(reg1_i2_atributo2);
	if (res != -1) {
		cout << "no hay espacio para reg1_i2_atributo2" << endl;
	}
	res=blqInstancia2.agregarRegistro(reg1_i2_atributo3);
	if (res != -1) {
		cout << "no hay espacio para reg1_i2_atributo3" << endl;
	}
	//escribe el bloque en el archivo de entidades
	archivoInstancias.escribirBloque(blqInstancia2,2);
	//libera el espacio de Bloque
	blqInstancia2.~Bloque();
    
   
    //entidad BRETEL 
	Registro reg2_i1_cabecera("BRETEL");
	Registro reg2_i1_idReg("3");
	Registro reg2_i1_atributo1("S"); //MONTABLE
	Registro reg2_i1_atributo2("N"); //FIJO
	Registro reg2_i1_atributo3("N");// FIJO
    
    //copia la segunda instancia
	Bloque blqInstancia3(tamBloque);
    //Agrego los registros
	res=blqInstancia3.agregarRegistro(reg2_i1_cabecera);
	if (res != -1) {
		cout << "no hay espacio para reg2_i1_cabecera" << endl;
	}
	res=blqInstancia3.agregarRegistro(reg2_i1_idReg);
	if (res != -1) {
		cout << "no hay espacio para reg2_i1_idReg" << endl;
	}
	res=blqInstancia3.agregarRegistro(reg2_i1_atributo1);
	if (res != -1) {
		cout << "no hay espacio para reg2_i1_atributo1" << endl;
	}
	res=blqInstancia3.agregarRegistro(reg2_i1_atributo2);
	if (res != -1) {
		cout << "no hay espacio para reg2_i1_atributo2" << endl;
	}
	res=blqInstancia3.agregarRegistro(reg2_i1_atributo3);
	if (res != -1) {
		cout << "no hay espacio para reg2_i1_atributo3" << endl;
	}
	//escribe el bloque en el archivo de entidades
	archivoInstancias.escribirBloque(blqInstancia3,3);
	//libera el espacio de Bloque
	blqInstancia3.~Bloque();    
    
   /*
    //entidad COPA
	Registro reg3_cabecera("COPA");
    Registro reg3_i1_idReg("3");
	Registro reg3_atributo1("N");
	Registro reg3_atributo2("S");
	Registro reg3_atributo3("N");
    Registro reg3_atributo4("N");
*/


}
/* descomentar para ejecutar.
int main() {
	cout << "archivo de entidades e intancias" << endl;
    

    //cargarEntidades ();
    cargarInstancias();
	cout << "Sale de Main" << endl;

	return 0;
}
*/
